//
//	"$Id: VideoDetect.h 2057 2008-10-24 08:27:01Z wang_haifeng $"
//
//	Copyright (c)1992-2007, ZheJiang Dahua Technology Stock CO.LTD.
//	All Rights Reserved.
//
//	Description:	所有坐标点和尺寸按照帧画面的绝对坐标系，分辨率变化后
//					相关参数需要重新设置
//	Revisions:		Year-Month-Day	SVN-Author	Modification
//

#ifndef __VIDEO_ANALYSE_API_H__
#define __VIDEO_ANALYSE_API_H__

#include "Types.h"
#include "VideoIn.h"

#ifdef __cplusplus
extern "C" {
#endif

/// \defgroup videoAnalyseAPI API Video Analyser
/// 视频分析接口
///	\n 调用流程图:
/// \code
///    ===========================
///				   |
///		   *createvideoAnalyser
///				   |
///				addRef
///				   |
///				getCaps
///				   |
///			   setScene
///				   |
///			   setStaffs
///				   |\--------------+
///		   +------\|			   |
///		   |  getPacket		   setRules
///		   +------/|			   |
///				   |/--------------+
///				release
///				   |
///    ===========================
/// \endcode
/// @{




/// 视频分析标尺类型
typedef enum VideoAnalyseStaffType
{
	videoAnalyseHorizontal,					///< 水平线段
	videoAnalyseVertical,					///< 垂直线段
	videoAnalyseAny,						///< 任意线段
	videoAnalyseCross,						///< 垂直面交线段
} VideoAnalyseStaffType;	


/// 视频分析服务类型
typedef enum VideoAnalyseServiceType
{
	videoAnalyseServiceAlarm					= 1 << 0,		///< 报警服务类型，含周界
	videoAnalyseServiceFaceDetection			= 1 << 1,		///< 人脸检测服务
	videoAnalyseServiceAlarmTrack				= 1 << 2,		///< 报警跟踪
	videoAnalyseServicePlateIdDetection			= 1 << 3,		///< 车牌识别检测服务
	videoAnalyseServiceParkDetection			= 1 << 4,		///< 车位检测服务
	videoAnalyseServiceVQD						= 1 << 5,		///< VQD检测服务
	videoAnalyseServiceHeadCount				= 1 << 6,		///< 人头统计服务
	videoAnalyseServiceAbnormalFaceDetection	= 1 << 7,		///< 异常人脸检测服务
	videoAnalyseServiceHumanShapeDetection	    = 1 << 8,		///< 人形检测服务
	videoAnalyseServiceFaceComparison   	    = 1 << 9,		///< 人脸比对服务
	videoAnalyseServicePersonVehicleNonmotor   	= 1 << 10,		///< 人车非检测服务
    videoAnalyseServiceAuto                     = 1 << 11,      ///< 自运行服务
} VideoAnalyseServiceType;	


/// 视频分析标尺结构，32字节
typedef struct VideoAnalyseStaff
{
	Point	start;			//起始点位置
	Point	end;			//终点位置
	uint	len;			//长度
	VideoAnalyseStaffType		staffType : 8;
	uint						reservedBits : 24;		///<保留位
	int							reserved[2];			///<保留
} VideoAnalyseStaff; 


/// 视频分析标定区域类型
typedef enum VideoAnalyseCalibrateAreaType 
{ 
	videoAnalyseCalibrateAreaGroud	,					///< 地面，需要N条竖直线段+M条水平线段（（N=3，M=1）；（N=2，M=2）；今后扩展）。
	videoAnalyseCalibrateAreaHorizontal,				///< 水平面，需要水平面上一点到地面点的投影垂直线段。
	videoAnalyseCalibrateAreaVertical,					///< 垂直面，需要垂直面与地面的交线。
	videoAnalyseCalibrateAreaAny,						///< 任意平面，N条竖直线段，及每条长度（N=3，及今后扩展）。
} VideoAnalyseCalibrateAreaType;	


/// 标定区域， 64字节
typedef struct VideoAnalyseCalibrateArea
{
	VideoAnalyseCalibrateAreaType		type : 8;			///< 区域类型
	uint								reservedBits : 24;	///< 保留位
	Polygon								area;				///< 区域
	uint								staffCount;			///< 标尺数量，指定staffs的数量
	VideoAnalyseStaff					*staffs;			///< 标尺
	int									reserved[11];		///<保留
}VideoAnalyseCalibrateArea;


/// 场景类型
typedef enum VideoAnalyseSceneType
{
	videoAnalyseSceneNormal,		///< 通用场景
	videoAnalyseSceneFar,			///< 远景场景
	videoAnalyseSceneMiddle,		///< 中景场景
	videoAnalyseSceneNear,			///< 近景场景
	videoAnalyseSceneIndoor,		///< 室内场景
	videoAnalyseSceneATM,			///< ATM场景
	videoAnalyseSceneTraffic,		///< 交通场景
	videoAnalyseFaceRecognition,	///< 人脸识别场景
	videoAnalyseSenceFaceDetection,	///< 人脸检测场景
	videoAnalyseSceneTrafficPatrol,	///< 交通巡视场景
	videoAnalyseSenceNr	
} VideoAnalyseSceneType;


/// 物体类型
typedef enum VideoAnalyseObjectType
{
	videoAnalyseUnknown = 0,		///< 未知
	videoAnalyseHuman,				///< 行人
	videoAnalyseVehicle,			///< 车辆
	videoAnalyseFire,				///< 火
	videoAnalyseSmoke,				///< 烟
	videoAnalysePlate,				///< 车牌
	videoAnalyseHumanFace,			///< 人脸
	videoAnalyseContainer,			///< 容器
	videoAnalyseAnimal,				///< 动物
	videoAnalyseTrafficLight,		///< 交通灯
	videoAnalysePastePaper,			///< 贴条
	videoAnalyseEntity,				///< 普通
    videoAnalyseHumanHead,          ///< 人头
} VideoAnalyseObjectType;


/// 车辆子类型
typedef enum videoAnalyseVehicleCategory
{
	videoAnalyseVehicleUnknown = 0,		///< 未知
	videoAnalyseVehicleMotor,			///< 机动车
	videoAnalyseVehicleNonMotor,		///< 非机动车
	videoAnalyseVehicleBus,				///< 公共汽车
	videoAnalyseVehicleBicycle,			///< 自行车
	videoAnalyseVehicleMotorcycle,		///< 摩托车
	videoAnalyseVehicleUnlicensedMotor,	///< 无牌机动车
} videoAnalyseVehicleCategory;

///视频分析车身颜色子类型
typedef enum VideoAnalyseCarColor
{
	videoAnalyseCarColorUnknown = 0,	///< 未知颜色
	videoAnalyseCarColorBlue,			///< 蓝色
	videoAnalyseCarColorYellow,			///< 黄色
	videoAnalyseCarColorWhite,			///< 白色
	videoAnalyseCarColorBlack,			///< 黑色
	videoAnalyseCarColorRed,			///< 红色
}VideoAnalyseCarColor;

///视频分析车牌颜色子类型
typedef enum VideoAnalysePlateColor
{
	videoAnalysePlateColorUnknown = 0,	///< 未知颜色
	videoAnalysePlateColorBlue,			///< 蓝色
	videoAnalysePlateColorYellow,		///< 黄色
	videoAnalysePlateColorWhite,		///< 白色
	videoAnalysePlateColorBlack,		///< 黑色
	videoAnalysePlateColorGreen,		///< 绿色
}VideoAnalysePlateColor;


/// 视频分析车牌子类型
typedef enum VideoAnalysPlateCategory
{
	videoAnalysePlateTypeUnknown = 0,	///< 未知
	videoAnalysePlateTypeNormal,		///< 蓝牌
	videoAnalysePlateTypeBlack,			///< 黑牌
	videoAnalysePlateTypeYellow,		///< 黄牌
	videoAnalysePlateTypeDoubleYellow,	///< 双层黄尾牌
	videoAnalysePlateTypePolice,		///< 警牌
	videoAnalysePlateTypeArmed,			///< 武警牌
	videoAnalysePlateTypeMilitary,		///< 部队号牌
	videoAnalysePlateTypeDoubleMilitary,///< 部队双层
	videoAnalysePlateTypeSAR,			///< 港澳特区号牌
	videoAnalysePlateTypeTrainning,		///< 教练车号牌
	videoAnalysePlateTypePersonal,		///< 个性号牌
	videoAnalysePlateTypeAgri,			///< 农用牌
	videoAnalysePlateTypeEmbassy,		///< 使馆号牌
	videoAnalysePlateTypeMoto,			///< 摩托车号牌
	videoAnalysePlateTypeTractor,		///< 拖拉机号牌
	videoAnalysePlateTypeOther,			///< 其他号牌
	videoAnalysePlateTypeBelarus421 = 20,	///< 车牌号码分3段，第一端包含4个数字或字母，第二段包含2个，第三段1个
	videoAnalysePlateTypeBelarus241,		///< 同上
	videoAnalysePlateTypeBelarus134,		///< 同上，该类型车牌为黄牌车
	videoAnalysePlateTypeBelarus43,			///< 车牌号码分2段，第一段包含4个数字或字母，第二段包含3个
	videoAnalysePlateTypeBelarus42,			///< 同上
	videoAnalysePlateTypeBelarus24,			///< 同上	
} VideoAnalysPlateCategory; 


/// 视频人脸子类型
typedef enum VideoAnalysHumanFaceCategory
{
	videoAnalyseHumanFaceTypeNormal = 0,///< 普通人脸
	videoAnalyseHumanFaceTypeHideEye,	///< 眼部遮挡
	videoAnalyseHumanFaceTypeHideNose,	///< 鼻子遮挡
	videoAnalyseHumanFaceTypeHideMouth,	///< 嘴部遮挡
	videoAnalyseHumanFaceTypeAdjacentFace,	///< 相邻人脸 (注，ATM，尾随)
	videoAnalyseHumanFaceTypeAbnormalFace	///< 异常人脸
} VideoAnalysHumanFaceCategory; 


/// 人脸检测场景大小脸切换
typedef enum VideoAnalyseFaceTypeDetection
{
	videoAnalyseFaceTypeBig = 0,	///< 大脸
	videoAnalyseFaceTypeSmall = 1,	///< 小脸
	videoAnalyseFaceTypeBoth = 2,	///< 大小脸同时启用
} VideoAnalyseFaceTypeDetection;


///人脸检测辅助跟踪控制类型
typedef enum VideoAnalyseContourAssistantTrackType
{
	videoAnalyseAssistContourAssistantTrackDisable = 0, ///< 不启用辅助跟踪
	videoAnalyseAssistContourAssistantTrackEnable = 1,	///< 启用辅助跟踪
} VideoAnalyseContourAssistantTrackType;


///DSP异常，重新调整的操作类型
typedef enum VideoAnalyseError 
{
	videoAnalyErrorStart = 0,	///< 开启视频分析器
	videoAnalyErrorStop = 1,	///< 结束视频分析器
} VideoAnalyseError;


/// 视频制式	
typedef enum  VideoAnalyseVideoStandard
{
	videoAnalyseVideoPAL = 0, ///< P制视频制式
	videoAnalyseVideoNTSC = 1,///<  N制视频制式
} VideoAnalyseVideoStandard;


///YUV数据类型
typedef enum VideoAnalyseColorFormat
{
	videoAnalyseColorFormatUYVY,		///< UYVU传递图像排列方式，u-y-v-y
	videoAnalyseColorFormatYUVYUV,		///< YUVYUV传递图像排列方式，y-u-v-y-u-v
	videoAnalyseColorFormatYYUVUV,		///< YYUVUV传递图像排列方式，y-y-u-v-u-v
	videoAnalyseColorFormatYYUUVV		///< YYUUVV传递图像排列方式，y-y-u-u-v-v
}VideoAnalyseColorFormat;


///YUV数据格式
typedef enum VideoAnalyseColorSpace
{
	videoAnalyseCSP420 = 0,			///< 420格式yuv数据
	videoAnalyseCSP422 = 1,			///< 422格式yuv数据
	videoAnalyseCSPUYVY = 2,		///< UYVY格式yuv数据
}VideoAnalyseColorSpace;


/// 传送YUV数据接口描述，128字节
typedef struct VideoAnalyseVideoYuv
{
	VideoAnalyseColorSpace colorSpace;					///< yuv的数据类型
	VideoAnalyseColorFormat format;						///< yuv图像排列方式
	char *Y;											///< Y分量
	char *U;											///< U分量
	char *V;											///< V分量
	int  width;											///< 图像宽度
	int  height;										///< 图像高度
	int  fps;											///< 图像帧率
	int  sequence;										///< 帧序号，便于抓图
	int  reserved[23];									///< 保留
} VideoAnalyseVideoYuv;


/// 视频红绿灯子类型,按位表示
typedef enum VideoAnalyseTrafficLightCategory
{
	videoAnalyseTrafficLightTypeTurnLeft = 1,	///< 左转
	videoAnalyseTrafficLightTypeStraight = 2,	///< 直行	
	videoAnalyseTrafficLightTypeTurnRight = 4,	///< 右转
	videoAnalyseTrafficLightTypeTurnU_Turn = 8,	///< 调头
}VideoAnalyseTrafficLightCategory;

///人脸信息结构体，保存相应的人脸信息
typedef struct  VideoAnalyseFaceInfo
{
	int 	faceConfidence;	///< 人脸分数
	Rect	faceRegion;		///< 存放人脸区域坐标的地址 

}VideoAnalyseFaceInfo;

/// 视频分析边界结构，描述一个折线或者多边形，视使用的语境而定
typedef struct VideoAnalyseBoundary
{
	uint							pointNumber;///< 顶点数目，折线必须不小于2，多边形不小于3
	Point*							points;		///< 构成折线或者多边形区域的点
} VideoAnalyseBoundary;


/// 车道线类型
typedef enum VideoAnalyseTrafficLineType
{
	videoAnalyseTrafficLineWhiteSolid = 0,	///< 白实线
	videoAnalyseTrafficLineWhiteDotted,		///< 白虚线
	videoAnalyseTrafficLineYellow			///< 黄线
} VideoAnalyseTrafficLineType;

/// 车道类型
typedef enum VideoAnalyseTrafficLaneType
{
	videoAnalyseTrafficLaneNormal = 0,		///< 普通车道
	videoAnalyseTrafficLaneNonMotor,		///< 非机动车车道
	videoAnalyseTrafficLaneLight_duty,		///< 小型车车道
	videoAnalyseTrafficLaneBus				///< 公交车车道
}VideoAnalyseTrafficLaneType;

/// 车道信息， 64个字节
typedef struct VideoAnalyseTrafficLane
{
	int							laneNumber : 8;		///< 车道编号，从0开始
	int							mode : 8;			///< 车道模式. 0表示车头, 1表示车尾
	int							directionMask : 8;	///< 车道行驶方向掩码，从低位到高位依次是:直行、左转、右转、调头，只对路口有效
	
	/// “RedLightCardNum” : 0,	卡口图片序号	表示将电警中的某一张图片作为卡口图片（共三张），0表示不采用，1~3,表示采用对应序号的图片
	/// \note 来源 <大华信息交换格式-智能化与智能交通分册.doc> 9	Traffic Snapshot 中 9.1.1	TrafficSnapshot配置
	/// \note 采用与线圈电警同样的处理思路, 配置后卡口取违章事件中的一张作为抓拍图片;
	int redLightCardNum : 8;	

	VideoAnalyseBoundary		stopLine;			///< 停止线，只对路口有效
	VideoAnalyseTrafficLineType	leftLineType : 8;	///< 左车道线类型
	VideoAnalyseTrafficLineType	rightLineType : 8;	///< 右车道线类型
	VideoAnalyseBoundary		leftLine;			///< 左车道线
	VideoAnalyseBoundary		rightLine;			///< 右车道线
	VideoAnalyseBoundary		detectLine;			///< 检测线，中间线
	VideoAnalyseTrafficLaneType	type : 8;			///< 车道类型
	int							waitingMode : 8;	///< 待行模式, 0-无待行区, 1-有待行区
	VideoAnalyseBoundary		preLine;			///< 前置线
	VideoAnalyseBoundary		postLine;			///< 后置线
	int							reserved;			///< 保留字段	
} VideoAnalyseTrafficLane;

/// 车道扩展信息，256个字节
typedef struct VideoAnalyseTrafficLaneExtended
{
	/// 卡口图片序号，作用与VideoAnalyseTrafficLane.redLightCardNum相同
	int							yellowLightCarNum : 8;
	int							reserved1 : 24;			///< 保留
	int							reserved[63];			///< 保留
}VideoAnalyseTrafficLaneExtended;

///交通信号灯信息 16个字节
typedef struct VideoAnalyseTrafficLight
{
	char	enable;			///< 车灯是否有效	
	char	reserve[3];		///< 保留
	int		typeMask;		///< 能表示的车灯类型掩码. 从低位到高位依次为:绿灯,黄灯,红灯,倒计时灯
	int		directionMask;	///< 交通灯指示的形式方向. 从低位到高位分别表示:左转,直行,右转,掉头.
	int		yellowLatch;	///< 黄灯亮的事件,单位为ms.
}VideoAnalyseTrafficLight;


//交通灯组信息. 32个字节
typedef struct VideoAnalyseTrafficLightGroup
{
	int							groupNumber : 8;	///< 灯组编号
	enum VideoAnalyseTrafficLightDirection
	{
		videoAnalyseTrafficLightHorizontal = 0,		///< 水平方向
		videoAnalyseTrafficLightVertical			///< 垂直方向
	}							direction : 8;		///< 灯组方向
	int							externalDetect : 8;	///< 是否为外接信号，0表示自己检测，1表示外接
	int							swingDetect : 8;	///< 摇摆检测，0表示不检测，1表示检测
	Rect						area;				///< 灯组区域坐标	
	char						lightNumber;		///< 灯组内的灯数量
	char						passType;			///< 通行依据: 0-绿灯亮时可以通行, 1-红灯灭时可以通行
	char						reserved[6];		///< 保留
	VideoAnalyseTrafficLight	*trafficLight;		///< 灯组内的灯信息
}VideoAnalyseTrafficLightGroup;


//分析场景 128个字节
typedef struct VideoAnalyseScene
{
	/// 场景类型
	VideoAnalyseSceneType	type : 8;
	
	/// 场景ID
	uint					id : 8;

	/// 背景扰动率，取值0-100，场景内的物体扰动越大,物体运动的速度越快（比如，有水面，有树叶等），此值越大。
	uint					disturbance : 8;

	/// 摄像机抖动率，取值0-100，反应静止摄像机抖动程度，抖动越厉害，值越大。
	uint					jitter : 8;

	/// 是否开启去抖动模块 0-不开启 1-开启
	uint					dejitter : 8;
	
	///< 第三方自定义配置数据的长度;
	int					customDataLen;
	
	///< 第三方自定义配置数据;
	char*				customData;

	/// 保留
	int						reserved[4];
	
	union
	{
		struct VideoAnalyseTrafficScene
		{
			/// 摄像头离地高度，单位cm
			ushort cameraHeight;
		
			/// 摄像头离地面检测区域中心的水平距离，单位cm
			ushort cameraDistance; 

			/// 近景点. 取y坐标
			ushort nearPoint;

			///  远景点. 取y坐标
			ushort farPoint;

			/// 近景点距离. 单位米
			float nearDistance;

			
			/// 远景点距离 单位米
			float farDistance;

			/// 交通场景类型,0-卡口场景，1-路口场景
			uchar type;
			
			/// 交通灯颜色校正：0-不校正，1-校正, 2-一直校正
			uchar  adjustLightColor;
		
			/// 车道个数
			uchar laneNumber;
			
			/// 灯组个数
			uchar groupsNumber;
			
			/// 交通车道信息.
			VideoAnalyseTrafficLane* lanes;
			
			/// 交通灯组信息，只对路口场景有效
			VideoAnalyseTrafficLightGroup* lightGroups;		
			
			/// 车牌字符暗示，提高识别率，GB2312格式，越前面的字符优先级越高。
			/// 比如plateHints="浙沪苏"表示浙牌优先级最高，上海其次，江苏最低。
			const char* plateHints;

			/// 左转弯分界线
			VideoAnalyseBoundary* leftDivisionLine;

			/// 右转弯分界线
			VideoAnalyseBoundary* rightDivisionLine;

			/// 黄色车牌字母识别开关，0-不识别字母 1-识别字母
			uchar yellowPlateLetter;

			/// 挂字车牌是否识别，0-不识别 1-识别
			uchar hangingWordPlate;

			/// 非标准警牌是否识别，0-不识别 1-识别
			uchar nonStdPolicePlate;

			/// 颜色校正等级，范围0~100
			uchar adjustLevel;
			
			/// 车道扩展信息，长度取值laneNumber
			VideoAnalyseTrafficLaneExtended* laneExtended;
		}traffic;
	
		struct VideoAnalyseFaceDetectionScene
		{
		  ///是否需要全景大图
		  uchar		  needScencImg;
		  ///需要人脸辅图的张数，此数值最大值由算法判断。辅图张数越多，后端的识别平台的正确性越高
		  uchar		  numOfAssistImg;
		}faceDetection;

		struct VideoAnalyseTrafficPatrolScene
		{
			/// 车牌字符暗示，提高识别率，GB2312格式，越前面的字符优先级越高。
			/// 比如plateHints="浙沪苏"表示浙牌优先级最高，上海其次，江苏最低。
			const char* plateHints;		
		}trafficPatrol;
		int placeholder[24]; ///< 占位符，保证这个联合体体为96字节
	}detail;
} VideoAnalyseScene;


/// 尺寸过滤器，20个字节
typedef struct VideoAnalyseSizeFilter
{
	enum	VideoAnalyseSizeFilterType
	{
		videoAnalyseSizeFilterByLength,		///< 按照宽度和高度，宽高之一小小于最小尺寸，或者两者都大于最大尺寸的物体将被过滤掉		
		videoAnalyesSizeFilterByArea		///< 按照面积，宽高的乘积小于最小面积，或者大于最大面积的物体将被过滤掉
	}		type;			///< 类型
	Size	minSize;		///< 物体最小尺寸，宽包模式分别表示宽和高，面积模式用w表示面积，h无效
	Size	maxSize;		///< 物体最大尺寸，宽包模式分别表示宽和高，面积模式用w表示面积，h无效
}VideoAnalyseSizeFilter;


//校准框
typedef struct VideoAnalyseSizeFilterCalibrateBox
{
	Point		centerPoint;			///<校准框中心点坐标	点的坐标归一化到[0,8192)区间。
	float		ratio;					///<相对基准校准框的比率	比如1表示基准框大小，0.5表示基准框大小的一半
}VideoAnalyseSizeFilterCalibrateBox;


/// 视频分析计量方式
typedef enum VideoAnalyseMeasureMode
{
	videoAnalyseMeasureModePixel			= 0,	///< “Pixel”-像素，不需要远端、近端标定
	videoAnalyseMeasureModeMetric			,		///< “Metric”-实际长度，单位：米
	videoAnalyseMeasureModeCalibratedPixel,			///< “CalibratedPixel”-远端近端标定后的像素
}VideoAnalyseMeasureMode;



///  校准框组
typedef struct VideoAnalyseSizeFilterCalibrateBoxGroup
{
	uint						number;					///< 校准框个数
	VideoAnalyseSizeFilterCalibrateBox	*values;		 ///< 校准框
}VideoAnalyseSizeFilterCalibrateBoxGroup;



/// 新尺寸过滤器，128字节
typedef struct VideoAnalyseSizeFilterNew
{
	VideoAnalyseMeasureMode		measureMode : 8;		/// 视频分析计量方式
	enum	VideoAnalyseSizeFilterTypeNew
	{
		videoAnalyseSizeFilterByLengthNew,		///< 按照宽度或高度，“宽大于最小宽且小于最大宽”或者“高大于最小高且小于最大高”，物体保留；
		videoAnalyseSizeFilterByWidthHeight,	///<按照宽度和高度，“宽大于最小宽且小于最大宽”且“高大于最小高且小于最大高”，物体保留；
	}		sizeType : 8;						///< 类型
	uint	bySize : 1;							///<是否按长宽过滤
	uint	byArea : 1;							///<是否按面积过滤
	uint	byRatio : 1;						///<是否按宽高比过滤
	uint	resevredBits : 13;					///< 保留位	
	Size	minSize;							///< 物体最小尺寸，宽包模式分别表示宽和高，面积模式用w表示面积，h无效
	Size	maxSize;							///< 物体最大尺寸，宽包模式分别表示宽和高，面积模式用w表示面积，h无效	
	Size	minAreaSize;						///< 最小面积矩形框尺寸
	Size	maxAreaSize;						///< 最大面积矩形框尺寸
	float	minArea;							///< 最小面积
	float	maxArea;							///< 最小面积	
	Size	minRatioSize;						///< 最小宽高比矩形框尺寸
	Size	maxRatioSize;						///< 最大宽高比矩形框尺寸
	float	minRatio;							///<最小宽高比	是浮点数，取值范围0.001~1000，默认值0.001
	float	maxRatio;							///<最大宽高比	是浮点数，取值范围0.001~1000，默认值1000.0
	VideoAnalyseSizeFilterCalibrateBoxGroup	* sizeCalibrateBoxs;		///< 尺寸校准框组，远端近端标定模式下有效
	VideoAnalyseSizeFilterCalibrateBoxGroup	* areaCalibrateBoxs;		///< 面积校准框组，远端近端标定模式下有效
	VideoAnalyseSizeFilterCalibrateBoxGroup	* ratioCalibrateBoxs;		///< 高度比校准框组，远端近端标定模式下有效
	int resevred[12];							///< 保留
}VideoAnalyseSizeFilterNew;

/// 物体过滤器，32字节
typedef struct VideoAnalyseObjectFilter
{
	VideoAnalyseObjectType		objectType : 8;			///< 物体类型
	uint						resevredBits : 24;		///< 保留位	
	VideoAnalyseSizeFilterNew	*sizeFilter;			///< 尺寸过滤器
	videoAnalyseVehicleCategory	 vechicleCategory;		///< 车辆子类型
	int resevred[5];									///< 保留
}VideoAnalyseObjectFilter;

/// 尺寸分类器
typedef struct VideoAnalyseSizeClassifier
{
	uint	number;			 ///< 分类个数
	float	*values;		 ///< 分类边界值数组，数组长度为分类个数-1
}VideoAnalyseSizeClassifier;


/// 视频分析背景类型
typedef enum VideoAnalyseBackgroud
{
	videoAnalyseBackgroudNormal		= 0, ///< 普通背景
	videoAnalyseBackgroudHighlight	= 1, ///< 高光背景
} VideoAnalyseBackgroud;


// 视频分析物体属性 
typedef enum  VideoAnalyseObjectAttribute
{
	videoAnalyseObjectCategory	 = 0x01,	///< 物体子类型
	videoAnalyseObjectSize		 = 0x02,	///< 物体大小
	videoAnalyseObjectColor		 = 0x04,	///< 物体颜色
	videoAnalyseObjectSpeed		 = 0x08,	///< 物体速度
	videoAnalyseObjectSign		 = 0x10,	///< 物体标志.对车辆而言,指车标
	videoAnalyseObjecAction		 = 0x20,	///< 物体动作检测
} VideoAnalyseObjectAttribute;


/// 特殊检测区属性
typedef enum VideoAnalyseSpecialRegionProperty
{
	videoAnalyseSpecialRegionPropertyHighlight		= 1 << 0,		///< 高亮
	videoAnalyseSpecialRegionPropertyRegularBlink	= 1 << 1,		///< 规律的闪烁
	videoAnalyseSpecialRegionPropertyIrregularBlink = 1 << 2,		///< 不规律的闪烁
}VideoAnalyseSpecialRegionProperty;

/// 特殊检测区, 32字节
typedef struct VideoAnalyseSpecialRegion
{
	Polygon				specialRegion;		///< 特殊检测区
	uint				propertyMask;		///< 特殊检测区属性
	int					resevred[5];		///< 保留
} VideoAnalyseSpecialRegion;

/// 缺省车牌的所属地
typedef enum VideoAnalyseDefaultProvince
{
	VideoAnalyseDefaultProvinceZang   = 0,		///< 藏
	VideoAnalyseDefaultProvinceXiang,			///< 湘
	VideoAnalyseDefaultProvinceZhe,				///< 浙
	VideoAnalyseDefaultProvinceChuan,			///< 川
	VideoAnalyseDefaultProvinceLiao,			///< 辽
	VideoAnalyseDefaultProvinceJin,				///< 晋
	VideoAnalyseDefaultProvinceShan,			///< 陕
	VideoAnalyseDefaultProvinceYu,				///< 豫
	VideoAnalyseDefaultProvinceNing,			///< 宁
	VideoAnalyseDefaultProvinceLu,				///< 鲁
	VideoAnalyseDefaultProvinceSu,				///< 苏
	VideoAnalyseDefaultProvinceHu,				///< 沪
	VideoAnalyseDefaultProvinceYue,				///< 粤
	VideoAnalyseDefaultProvinceMin,				///< 闽
	VideoAnalyseDefaultProvinceGan,				///< 甘
	VideoAnalyseDefaultProvinceXin,				///< 新
	VideoAnalyseDefaultProvinceHei,				///< 黑
	VideoAnalyseDefaultProvinceJi,				///< 冀
	VideoAnalyseDefaultProvinceQing,			///< 青
	VideoAnalyseDefaultProvinceMeng,			///< 蒙
	VideoAnalyseDefaultProvinceTianJin,			///< 津
	VideoAnalyseDefaultProvinceE,				///< 鄂
	VideoAnalyseDefaultProvinceJiLin,			///< 吉
	VideoAnalyseDefaultProvinceJiangXi,			///< 赣
	VideoAnalyseDefaultProvinceJing,			///< 京
	VideoAnalyseDefaultProvinceWan,				///< 皖
	VideoAnalyseDefaultProvinceGui,				///< 桂
	VideoAnalyseDefaultProvinceQian,			///< 黔
	VideoAnalyseDefaultProvinceGuiZhou,			///< 贵
	VideoAnalyseDefaultProvinceYun,				///< 云
	VideoAnalyseDefaultProvinceQiong,			///< 琼
	VideoAnalyseDefaultProvinceChongQing,		///< 渝
	VideoAnalyseDefaultProvincePolice,			///< 警
	VideoAnalyseDefaultProvinceJun,				///< 军
	VideoAnalyseDefaultProvinceJiao,			///< 教
}VideoAnalyseDefaultProvince;

//车牌检测模式
typedef enum VideoAnalysePlateRecognizeMode
{
	PlateRecognizeImageMode = 0,							///< 静态车牌检测模式
	PlateRecognizeVideoMode,								///< 动态车牌检测模式
	PlateRecognizeCombineMode,								///< 混合车牌检测模式
	PlateRecognizeUnKnown,									///< 其他
}VideoAnalysePlateRecognizeMode;

///<主动抓拍触发源
typedef enum SnapshotTriggerSrc
{
	triggerSourceSerial,		///< 串口主动抓拍
	triggerSourceSimulate,		///< 模拟主动抓拍
	triggerSourceUnkown,		///< 其他
}SnapshotTriggerSrc;


/// 车牌识别算法参数, 32字节
typedef struct VideoAnalysePlateParam
{
	short shearAngle;							///< 错切校正角度错切角度为负：向右错切，为正则反之
	short rotaryAngle;							///< 旋转校正角度,旋转角度为正：逆时针旋转,反之为顺时针
	VideoAnalyseDefaultProvince priorWord : 8;	///< 缺省车牌的所属地
	char resevred1[3];							///< 保留
	int resevred[6];							///< 保留
} VideoAnalysePlateParam;

/// 视频分析服务器高级参数配置，128字节
typedef union VideoAnalyseAdvanceParam
{
	/// 周界高级参数
	struct videoAnalyseAlarm
	{
		int bKThrd;				///< 判断为背景分布的阈值，默认值717，取值范围0~1024，推荐使用默认值。
		int voteThrd;			///< 基于块判别时，前景背景的阈值，默认值1600，推荐取值范围800~5000。
		int	varThrd;			///< 判断符合某分布的方差阈值，略微降低该值可以提高在昏暗条件下的检测结果，默认值6，推荐取值范围3~6。
		int initialVar;			///< 初始的分布方差值，降低该值可以提高低分辨环境下的结果，默认值10，推荐取值范围5~10。
		int initiaWeight;		///< 初始的分布权重，影响更新速度，推荐使用默认值，默认值51，取值范围0~1024。不建议修改。
		int learningRate;		///< 模型的更新率，目标快速运动的时候适用于高更新率，推荐值范围4~64, 取值范围0~256。
		int voteRadius;			///< 粒度，r*r半径内的像素结果相同，取值范围1~2。
		int pixThrd;			///< 连通域阈值，目标至少拥有的像素数，取值范围1~全屏像素值，默认值64。
		int areaThrd;			///< 连通域面积阈值，取值范围0~256，默认值75。与widthThrd和heightThrd相当，如果低于widthThrd * heightThrd，则widthThrd * heightThrd起主要过滤作用。
		int waitingThrd;		///< 消失等待阈值，同一个目标等待其消失的帧数，推荐取值范围1~10，默认1。
		int distanceThrd;		///< 追踪设定的距离阈值，默认值30，取值范围。推荐取值范围10~100，默认30。
		int personArea;			///< 人所占面积，取值：1~全屏像素值 根据基准最大面积。
		int vehicleArea;		///< 车所占面积，同personArea。
	} alarm;

	/// 人脸检测高级参数
	struct VideoAnalyseFaceParam
	{
		uchar trackerNums;		///< 多人脸同时追踪人脸数，范围1~10，默认3
		uchar decFrameRate;		///< 多帧之中人脸检测一次设置,范围1~5，默认3
		uchar decWaitThresh;	///< 等待一定帧数如果没有检测，强制消失，范围0~100，默认15
		uchar decLevel;			///< 人脸检测灵敏度设置,范围0~100, 值越大灵敏度越高，默认100
		uchar enableEnhance;	///< 是否使用图像增强，1使能，0禁止，默认0
		uchar faceSnapMode;		///< 人脸抓图模式，0表示一个人脸id产生一张最优人脸报警，1表示一个人脸id产生第一张人脸和最优人脸报警，
								///< 2表示一个人脸id产生每个间隔时间的最优人脸报警，3表示一个人脸id产生第一张人脸和每个间隔时间的最优人脸报警
								 ///< 4表示一个人脸id产生一张最优报警后可强制报警  5表示一个人脸id产生第一张人脸和一个最优报警后可强制报警
								 ///< 6表示最快抓拍一个人脸模式
		uchar snapInterval;		///< 抓拍间隔，只有在多张最优模式时才设置该参数，范围1-10s，默认5s
		uchar orignalTransport; ///< 是否开启全图传输，1-打开，0-关闭，默认0
		uchar verticalAngle;	///< 垂直角度，范围0~90，默认30，在该角度范围内的人脸上报
		uchar levelAngle;		///< 水平角度，范围0-90，默认30，在该角度范围内的人脸上报
		uchar confidence;		///< 人脸置信度，范围0~100，默认61，优于该值的人脸上报
		uchar quality;			///< 人脸质量分，范围0~100，优于该值的人脸上报
		uchar sanpTimes;		///< 抓拍次数，范围1~3
	} face;

	/// 车牌识别算法参数
	struct VideoAnalysePlateLicenceParam
	{
		short shearAngle;							///< 错切校正角度错切角度为负：向右错切，为正则反之
		short rotaryAngle;							///< 旋转校正角度,旋转角度为正：逆时针旋转,反之为顺时针
		VideoAnalyseDefaultProvince priorWord : 8;	///< 缺省车牌的所属地
		int resevred : 24;							///< 保留
	} plate;
	
	/// 异常人脸检测高级参数
	struct VideoAnalyseAbnormalFaceParam
	{
		uchar trackerNums;		///< 多人脸同时追踪人脸数，范围1~10，默认3
		uchar decFrameRate;		///< 多帧之中人脸检测一次设置,范围1~5，默认3
		uchar decWaitThresh;	///< 等待一定帧数如果没有检测，强制消失，范围0~100，默认15
		uchar decLevel;			///< 人脸检测灵敏度设置,范围0~100, 值越大灵敏度越高，默认100
		uchar enableEnhance;	///< 是否使用图像增强，1使能，0禁止，默认0
	} abnormalFace;

	/// 人车非检测高级参数
	struct VideoAnalyseCarPersonBike
	{
		uchar confidence;		///< 物体置信度，范围0~100，优于该值的人脸上报
		uchar quality;			///< 物体质量分，范围0~100，优于该值的人脸上报
		uchar snapMode;			///< 人机非抓拍策略，0表示最优模式，1表示最快模式
		uchar snapInterval;		///< 抓拍间隔,只有在最优模式时才设置该参数，范围1-10s
		uchar snapTimes;		///< 抓拍次数，范围1~3
	} carPersonBike;

	int placeholder[32]; 		///< 占位符，保证这个联合体体为128字节
}VideoAnalyseAdvanceParam;

/// 不同区域各种类型物体的检测模块配置，没有配置的区域和类型不需要检测，128字节
typedef struct VideoAnalyseModuleConfig
{
	VideoAnalyseObjectType	type : 8;			///< 默认物体类型
	uint				sensitivity : 8;		///< 灵敏度		取值1-10		
	int						snapshot : 8;		///< 是否对识别物体抓图，局限于物体的BoundingBox之内，抓图时机由算法选择，以特征较明显为好
	VideoAnalyseBackgroud	backgroud : 8;		///< 背景类型
	VideoAnalyseBoundary	detectRegion;		///< 检测区域，减少区域面积可以提高算法速度
	uint					maskRegionNumber;	///< 检查区域中需要排除的区域的个数，一般是可能会对算法引起干扰的区域，一个检查区域可能包括多个孔
	VideoAnalyseBoundary	*maskRegions;		///< 排除区域列表
	VideoAnalyseBoundary	trackRegion;		///< 跟踪区域，检查区域也是算法的跟踪区域的一部分
	VideoAnalyseSizeFilter	sizeFilter;			///< 尺寸过滤器
	uint					attributes;			///< 识别物体的哪些信息，是VideoAnalyseObjectAttribute掩码组合
	VideoAnalyseSizeClassifier *sizeClassifier;	///< 尺寸分类器，根据边界值对有效物体尺寸进行分类，指针为空表示不分类
	uchar					maxSpeed;			///< 允许检测出来的最大速度，单位km/h，如果超过此速度，可能是出错了，应该替换为此速度。
	uchar					antiDisturbance;	///< 去扰动模块开关 0-关，1-开
	uchar					shadow;				///< 阴影抑制开关 0-关，1-开
	uchar					backlight;			///< 是否为逆光场景，设置后以便优化算法 0-否，1-是
	uint					categoryMask;		///< 识别物体子类型掩码,对应物体类型的子类型
	uchar					disturbance;		///< 景扰动率，设置后以便优化算法。取值0-100，场景内的物体扰动越大,物体运动的速度越快（比如，有水面，有树叶等），此值越大
	uchar					detectBalance;		///< 漏检和误检平衡	0-折中模式(默认) 1-漏检更少 2-误检更少
	uchar					accuracy;			///< 精度(0~10)
	uchar					contourAssistantTrack;		///< 轮廓辅助跟踪模式，见 VideoAnalyseContourAssistantTrackType
	VideoAnalyseSizeFilterNew	* sizeFilterNew;		///< 新尺寸过滤器，针对所有的物体
	VideoAnalyseObjectFilter	* objectFilters;		///< 物体过滤器,是一个数组，数组元素数量，由objectFiltersCount指定；
	uint					objectFiltersCount : 8;		///< 物体过滤器数量
	uint					specialRegionsCount : 8;	///< 特殊检测区数量
	uint					resevredBits : 16;			///< 保留位
	Size					* objectImageSize;			///< 物体抠图尺寸 高，宽取值均 取值：>=0,  0 表示自动调整大小
	VideoAnalyseSpecialRegion	* specialRegions;		///< 特殊检测区,是一个数组，数组元素数量，由specialRegionsCount指定；
	uchar					plateAnalyseMode;			///< 车牌识别模式:0-只识别车头牌照，1-只识别车尾牌照，2-车头牌照优先（场景中大部分车均是车头牌照），3-车尾牌照优先（场景中大部分车均是车尾牌照）			
	uchar					pkMode;						///< 启用PK模式，0-不启用，1-启用
	uchar					diffZeroOrD;		///识别0和D的区分 0-是，1-否
	char					reserved1[1];	 	///< 保留
	VideoAnalyseServiceType	serviceType;	///< 视频分析服务类型
	VideoAnalysePlateParam *plateParam;			///< 车牌识别算法参数
	VideoAnalyseAdvanceParam *advanceParam;		///< 分析服务器高级参数
	int						resevred[6];		///< 保留 
} VideoAnalyseModuleConfig;


/// 视频分析物体动作
typedef enum VideoAnalyseObjectAction
{
	videoAnalyseActionAppear		= 0,	///< 第一次出现在检测区域中，或者跟踪时物理分离动作中尚未确认的新物体。
	videoAnalyseActionMove			= 1,	///< 正在运动，物体被正常跟踪。
	videoAnalyseActionStay			= 2,	///< 物体停止运动，这个物体不会在出现在下一帧物体列表中，物体开始移动后再恢复在列表中。
	videoAnalyseActionRemove		= 3,	///< 物体从原来的区域移除，或者被遮盖，或者跟踪失败，移除的物体ID不会被自动删除，并且物体重现出现是有可能再次被使用。
	videoAnalyseActionDisappear		= 4,	///< 运动到跟踪区域之外，或者达到了算法跟踪物体的上限而被清除，消失的物体ID将不再出现。
	videoAnalyseActionSplit			= 5,	///< 从其他物体中分离出来，可以用来检测物体遗留，关联ID表示从这个ID对应物体分离。
	videoAnalyseActionMerge			= 6,	///< 合并到其他物体，可以用来检查物体保全，关联ID表示合并到这个ID对相应的物体。
	videoAnalyseActionRename		= 7,	///< 如果算法无法确定分离动作中某个物体是原先同一个物体，应该创建先一个新的物体，证据充分后再重命名为旧的物体ID，关联ID表示暂时使用的新的ID。
} VideoAnalyseObjectAction; 

/// 图片类型
typedef enum VideoAnalyseImageType
{
	videoAnalyseJpegHighResolution = 0,		///< JPEG格式，高分辨率图片
	videoAnalyseJpegLowResolution,			///< JPEG格式，低分辨率图片
	videoAnalyseBitmap,						///< BMP格式图片
	videoAnalyseCutout,						///< 抠图格式 
}VideoAnalyseImageType;

/// 视频分析截图，128字节
typedef struct VideoAnalyseImage
{
	uchar	*buffer;		///< 物体抓图数据缓冲指针，指向完整的BMP或者JPEG文件格式数据
	ulong	length;			///< 物体抓图数据缓冲有效长度
	ushort	width;			///< 图像宽度
	ushort	height;			///< 图像高度
	VideoAnalyseImageType imageType;	///< 图片类型	   
	int		resevred[28];	///< 保留
} VideoAnalyseImage;

/// 包含扩展的视频规则和事件的定义
#include "VideoAnalyseRule.h"

/// 128字节 规则详细能力
typedef union VideoAnalyseRuleExtraParam
{
	struct videoAnalyseFaceDetection						///< 人脸规则特有参数能力
	{
		int traceNumber;									///< 人脸追踪个数
	} faceDetection;
	
	int placeholder[32]; ///< 占位符，保证这个联合体体为128字节
} VideoAnalyseRuleExtraParam;

///通用规则能力集，共32个字节，包含触发位置，支持的物体类型
typedef struct VideoAnalyseRuleAbilitySet
{	
	uint	objectTypeMask;						///< 支持的物体类型掩码，对应的物体的位掩码为1，表示支持，一个规则可支持多个物体
	VideoAnalyseRuleType		ruleType : 8;	///<规则类型
	///\穿越警戒区检测规则、运动检测规则支持动作类型，对其它规则无效
	///\ 穿越警戒区检测动作掩码，参见 videoanalyseRule.h VideoAnalyseDetectAction
	///< 运动检测 奔跑类型掩码，取值见videoanalyseRule.h  VideoAnalyseRunDetectType
	ulong						actionMask : 16;	
	uint	triggerPosition		: 1;			///<穿越警戒线触发位置能力标识位	
	uint	reservedBits		: 7;			///< 保留位
	VideoAnalyseRuleExtraParam *	extraParam;	///< 规则详细能力
	int	reserved[5];							///< 保留
}VideoAnalyseRuleAbilitySet;


/// 视频分析设备特性结构，32字节VideoAnalyseCapsScene
typedef struct VideoAnalyseCapsScene
{
	VideoAnalyseRuleAbilitySet *	ruleEnableSets;			///<各类型规则触发位置能力集，是一个数组，数组元素数量，由ruleEnableSetsCount指定；
	uint							ruleEnableSetsCount : 8;	
	VideoAnalyseSceneType			type : 8;				/// 场景类型
	uint							reservedBits : 16;		///< 保留位
	uint							objectTypeMask;		///<	物体类型掩码
	int								reserved[5];			///< 保留
}VideoAnalyseCapsScene;

typedef enum VideoAnalyseSupportedVideoChannelType
{
	VideoAnalyseSupportedVideoChannelTypeAnolog		=	1<<0,		///< 模拟设备
	VideoAnalyseSupportedVideoChannelTypeDigital	=	1<<1,		///< 数字设备
	VideoAnalyseSupportedVideoChannelTypeBoth		=	1<<2,		///< 混合设备	
}VideoAnalyseSupportedVideoChannelType;


/// 视频分析设备特性结构，128字节
typedef struct VideoAnalyseCaps
{
	uint	objectTypeMask;			///< 支持的物体类型掩码
	uint	sceneTypeMask;			///< 支持的场景掩码,见VideoAnalyseSceneType
	char	maxStaffs;				///< 最大标尺个数
	char	maxModules;				///< 最大分析模块个数
	char	maxPointsOfPolyline;	///< 折线最大顶点数
	char	maxPointsOfPolygon;		///< 多边形最大顶点数
	uint	ruleTypeMask[8];		///< 支持的规则类型
	uint					maxRules : 8;					///< 一次设置的最大规则数
	VideoAnalyseMeasureMode measureModeMask : 8;			///<支持的视频分析计量方式掩码；
	uint					maxExcludeRegions : 8;				///< 支持非检测区域个数
	uint						supportedScenesCount : 8;
	VideoAnalyseCapsScene *		supportedScenes;			///<场景能力定义，是一个数组，数组元素数量，由supportedScenesCount指定；
	VideoAnalyseSupportedVideoChannelType	supportedVideoChannelTypeMask : 8; ///<设备可支持的类型集合
	int						reservedBits : 24;				///< 保留位
	uint16		retroMinDistance;		///< 逆行最小距离 相对于8192分辨率下的像素点
	uint16		retroMaxDistance;		///< 逆行最大距离 相对于8192分辨率下的像素点
	uint		advanceParamMask;		///< 支持高级参数设置的算法服务类型掩码, 算法类型见 VideoAnalyseServiceType
	int						reserved[16];					///< 保留
} VideoAnalyseCaps;


/// 轨迹点， uint pointNumber, 轨迹点个数; Point * points, 轨迹点坐标数组；
typedef VideoAnalyseBoundary VideoAnalyseTrackPointGroup;


/// 视频分析物体信息，120字节（注：注释原为128字节，但结构体事实一直为120字节）
typedef struct VideoAnalyseObject
{
	uint					id;				///< 物体ID，应该是一直累加的，除非ID溢出。ID生命周期开始的动作有Appeare/Split/Rename，ID生命周期结束的动作有Disappear/Merge/Remove/Rename
	uint					relativeId;		///< 相关物体ID，如果物体动作为Split/Merge/Rename的需要相关ID，否则表示所属物体的ID，比如车牌的relativeId是车辆的ID
	VideoAnalyseObjectType	type : 8;		///< 物体类型
	uint					confidence : 8;	///< 置信度，0-255，越大表示越高
	VideoAnalyseObjectAction action : 8;	///< 物体动作
	int						category : 8;	///< 物体类型中的子类别，不同的类型对应的子类别不同，比如车牌的类别取VideoAnalysPlateCategory枚举类型的值
											///< 物体类型为交通灯时，取VideoAnalyseTrafficLightCategory位与值,如category & videoAnalyseTrafficLightTypeStraight表示直行红灯状态,非0表示红灯亮，0表示红灯灭
	Rect					boundingBox;	///< 包围盒
	Point					centroid;		///< 物体型心
	VideoAnalyseBoundary	contour;		///< 较精确的轮廓多边形
	Color					mainColor;		///< 物体主要颜色
	VideoAnalyseImage		*image;			///< 物体截图，指针为空表示无抓图数据
	char					*text;			///< 物体上相关的带0结束符文本，比如车牌，集装箱号，type为videoAnalyseVehicle时表示车标等等，UTF-8格式，指针为空表示没有相关文本
	char					sizeClass;		///< 物体尺寸经过尺寸分类器分类后的结果，从0开始编号
	uchar					speed;			///< 物体速度，单位km/h
	VideoAnalyseObjectEx	*extra;			///< 额外的物体信息，不同物体类型定义不同，0表示无效
	VideoAnalyseTrackPointGroup * trackPoints;		///< 物体的运行轨迹点
	uint		            imageNum;		///< 抓图张数
	uint					reserved[12];	///< 保留
} VideoAnalyseObject;

/// 物体信息，128字节（该物体信息将用于元数据的序列化）
typedef struct VideoObject
{
	uint					id;				///< 物体ID，应该是一直累加的，除非ID溢出。
	VideoAnalyseObjectType	type : 8;		///< 物体类型
	uint					confidence : 8;	///< 置信度，0-255，越大表示越高
	VideoAnalyseRuleType	ruleType : 8;	///< 报警框类型,非报警时填255
	char					res;			///< 保留
	Rect					contour;		///< 跟踪框或者报警框坐标
	VideoObjectEx			extra;			///< 额外的物体信息
	uint					reserved[10];	///< 保留
}VideoObject;

/// 图片数据信息 32个字节
typedef struct VideoAnalyseImageInfo
{
	VideoAnalyseImageType imageType;	///< 图片类型	   
	int imageDatalen;					///< 图片数据长度
	char *imageData;					///< 图片数据
	int reserved[5];					///< 保留字节
}VideoAnalyseImageInfo;

/// 视频分析包，128字节
typedef struct VideoAnalysePacket
{
	uint				objectNumber;	///< 物体个数
	VideoAnalyseObject* objects;		///< 物体列表
	uint64				pts;			///< 时间戳，毫秒为单位
	ulong				sequence;		///< 帧序号，用于校验是否丢帧，本地分析时帧序号同视频编码后序号，远程解码分析时帧序号同解码前的帧序号。
	ulong				utc;			///< 对应的UTC(1970-1-1 00:00:00)秒数
	uchar				ch;				///< 临时使用，待底层完成DSP多通道分析后取消。
	uchar				mark;			///< 抓拍图片的mark标记，如果不是抓拍图片，标记不变或者为0.
	ushort				utcms;			///< UTC时间对应的毫秒数
	uint				eventNumber;	///< 事件个数
	VideoAnalyseEvent*	events;			///< 事件列表
	void*				extra;			///< 附加信息，在智能交通中表示线圈/雷达/IO等抓拍信息
	void*				source;			///< 视频分析数据（如YUV数据）地址
	void*				track;			///< 视频智能分析物体轨迹帧数据缓冲指针
	uint				trackBytes;		///< 视频智能分析物体轨迹帧数据缓冲有效字节数
	int					customDataLen;	///< 第三方自定义识别数据的长度;
	char*				customData;		///< 第三方自定义识别数据;
	int					imageNum;		///< 图片个数
	VideoAnalyseImageInfo* imageInfo;	///< 图片信息
	int					reserved[15];	///< 保留字节
} VideoAnalysePacket;

/// 元数据分析包，128字节
typedef struct VideoObjectPacket
{
	VideoObject* 		objects;		///< 物体列表
	int					 number;		///< 物体个数
	uint64				 pts;			///< 时间戳，毫秒为单位
	int					reserved[28];	///< 保留字节
} VideoObjectPacket;

/// 视频分析数据格式结构，128字节
typedef struct VideoAnalyseFormat
{
	int		width;		///< 视频分析源水平分辨率，8的倍数,大于64 
	int		height;		///< 视频分析源垂直分辨率，8的倍数,大于64
	float	fps;		///< 帧率值，NTSC/PAL不区分
	char	mirror;		///< 是否开启镜像功能，0-不开启，1-开启
	char	flip;		///< 是否开启翻转功能，0-不开启，1-开启
	char	rotate90;	///< 分辨率旋转标志。0-不旋转，1-顺时针90°，2-逆时针90°。分辨率旋转后，width和height也要做相应旋转。
	int reserved[28];	///< 保留字节
} VideoAnalyseFormat;


/// 视频分析模式
typedef enum VideoAnalyseMode
{
	/// 禁止视频分析（识别）
	videoAnalyseModeDisabled,
	
	/// 抓拍分析（识别）模式
	videoAnalyseModeSnapshot,
	
	/// 连续分析（识别）模式
	videoAnalyseModeContinuous,
	
	/// 混合抓拍分析（识别）模式
	videoAnalyseModeCombine
}VideoAnalyseMode;


/// 智能交通抓拍次数,8字节
typedef struct VideoAnalyseTrafficSnapTimes
{
	VideoAnalyseRuleType		type : 8;		///< 违章类型
	int							snapTimes : 8;	///< 抓拍次数
	uchar						reserved[4];	///< 保留
}VideoAnalyseTrafficSnapTimes;

/// 视频分析异常事件码
typedef enum VideoAnalyseExceptionCode
{
	videoAnalyseDSPError = 0		///< 视频分析DSP错误，对应参数无；	
}VideoAnalyseExceptionCode;


/// 视频分析内部选项 32字节
typedef struct VideoAnalyseInternalOption 
{	
	int		index;				///< 选项序号
	char*	keyName;			///< 选项名称	加密后的名称，界面上需要输入密码解密后才能显示明文，否则只能显示密文(注，字符串，以NULL结束)
	int		value;				///< 选项取值
	int		minValue;			///< 最小值
	int		maxValue;			///< 最大值
	uint	reserved[3];		///< 保留
}VideoAnalyseInternalOption;		

/// 视频分析消息类型
typedef enum VideoAnalyseMessageType
{
	videoAnalyseMessageTypePacket = 1 << 0,	///< 视频分析包消息，表示有分析出新包
}VideoAnalyseMessageType;


/// 视频分析消息 64字节
typedef struct VideoAnalyserMessage
{
	struct VideoAnalyser *		thiz;				///< 视频分析指针	
	VideoAnalyseMessageType		messageType;		///< 消息类型
	int							channel;			///< 视频分析通道号
	uint						reserved[13];		///< 保留
}VideoAnalyserMessage;

///视频分析异常事件回调函数指针类型定义
typedef int ( * VideoAnalyseExceptionCallback )(VideoAnalyseExceptionCode code, void * para);


/// 视频分析DSP信息，128字节
typedef struct VideoAnalyseDSPInfo
{
	long long id;			///< 视频分析器ID
	int reserved[30];		///< 保留
}VideoAnalyseDSPInfo;



/// 视频覆盖参数, 参考VIDEO_COVER_PARAM(Video.h) , 64字节
typedef struct VideoAnalyserVideoCover
{
	int					enable;			///< 遮盖区域使能 （取值范围：0禁止 1使能）
	Rect				rect;			///< 遮盖区域
	Color				color;			///< 遮盖区域颜色	
	int					reserved[10];	///< 保留
}VideoAnalyserVideoCover;

/// 强制视频产生智能事件类型,128字节
typedef struct VideoForceBreaking
{
	VideoAnalyseRuleType ruleType;				///< 规则类型
	uchar				ruleId;					///< 规则ID号
	uchar				reserved1[3];			///< 保留
	int					reserved[5]; 			///< 保留
	union
	{
		struct VideoAnalyseGatewayParam			///< 出入口事件参数
		{
			SnapshotTriggerSrc TriggerSrc;		///< 触发抓拍的类型
		}gateWayParam;

		struct VideoAnalyseFaceDetectParam		///< 人脸检测事件参数
		{
			uint				faceId;			///< 报警人脸id
		}faceDetectParam;

		int placeholder[25];					///< 占位符，保证这个联合体体为100字节
	} info;
	
}VideoForceBreaking;

/// 智能抓图图片信息
typedef struct VideoAnalyseSnapInfo
{
	VideoAnalyseImageType imageType;	///< 图片类型	   
	unsigned int imageWidth;			///< 分辨率宽
	unsigned int imageHeigt;			///< 分辨率高
	unsigned char imageQuality;			///< 图片质量 取值1-6，值越大，质量越好
	unsigned char res[3];				///< 保留
	int reserved[4];					///< 保留字节
}VideoAnalyseSnapInfo;


/// 配置智能抓图属性
typedef struct VideoAnalyseSnapOption
{
	int					   imageNum;    ///< 图片个数
	VideoAnalyseSnapInfo* imageInfo;	///< 图片信息
	uint reserved[30];					///< 保留
}VideoAnalyseSnapOption;

/// 配置智能抓图OSD,128字节
typedef struct VideoAnalyseSnapOSDInfo
{
	uint	timeShow : 1;				///< 1:显示时间标题 0:不显示
	uint	ipShow : 1;					///< 1:显示ip地址 0:不显示
	uint	addrShow : 1;				///< 1:显示监控地址 0:不显示
	uint	detailAddrShow : 1;			///< 1:显示详细监控地址 0:不显示
	uint	plateNumberShow : 1;		///< 1:显示车牌号码 0:不显示
	uint	plateColorShow : 1;			///< 1:显示车牌颜色 0:不显示
	uint	gatewayDirectionShow : 1;	///< 1:显示出入口方向 0:不显示
	uint	roadNoShow : 1;				///< 1:显示道路编号 0:不显示
	uint	bitReserved: 24;			///< 保留位
	uchar	*addrInfo;					///< 地址信息
	uchar	*detailAddrInfo;			///< 详细地址信息
	uchar	*timeFormat;				///< 格式化字符串，如"yyyy-MM-dd HH:mm:ss tt"
										///< yy = 年，不带世纪 yyyy = 年，带世纪
										///< M = 非0起始月 MM = 0起始月 MMMM = 月名称
										///< d = 非0起始日 dd = 0起始日
										///< H = 非0起始24小时 HH = 0起始24小时 h = 非0起始12小时 hh = 0起始12小时
										///< tt = 显示上午或下午
	uint	fontSize;					///< OSD字体大小，单位像素
	Color	color;						///< OSD颜色
	uchar	point;						///< OSD叠加位置,0:左上角 1:右上角 2:左下角 3:右下角
	uchar	gatewayDirectionInfo;		///< 出入口方向信息, 1:进口，0:出口
	uchar	reserved1[2];				///< 保留字节
	uchar	*roadNo;					///< 道路编号
	uint reserved[24];					///< 保留
}VideoAnalyseSnapOSDInfo;

/// 视频分析接口，504字节（注：原注释为512字节，实为504字节）
typedef struct VideoAnalyser
{
	/// 底层私有数据
	void *priv;



	/// 增加接口引用
	int (*addRef)(struct VideoAnalyser *thiz);


	/// 释放接口
	int (*release)(struct VideoAnalyser *thiz);


	/// 得到黑屏支持的特性。
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [out] caps 指向视频分析特性结构VideoAnalyseCaps的指针。
	/// \retval 0  获取成功。
	/// \retval <0	获取失败。	
	/// \note getCaps接口中，参数中有些元素是指针，引用了内存（不管是何种类型的，
	/// 动态或非动态的），由底层服务提供者，管理指针指向的内存；底层服务提供者
	/// （内存管理者）要保证在接口函数的调用过程中及调用后，指针指向内容的正确性，
	/// 可靠性；上层使用者不管理参数元素指针指向的相关内存；
	int (*getCaps)(struct VideoAnalyser *thiz, VideoAnalyseCaps * caps);


	/// 设置视频分析的场景
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] scene 视频分析场景信息。
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	/// \note VideoAnalyseScene结构体内有指针内嵌多层，请注意指针初始化及释放
	int (*setScene)(struct VideoAnalyser *thiz, VideoAnalyseScene *scene);


	/// 设置标定区域
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] count 标定区域个数
	/// \param [in] area 视频分析标定区域结构VideoAnalyseCalibrateArea数组。
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	/// \note 老的接口为 "设置视频分析的标尺", 废除取消, 原形为: int (*setStaffs)(struct VideoAnalyser *thiz, int count, VideoAnalyseStaff *staffs);
	int (*setCalibrateArea)(struct VideoAnalyser *thiz, int count, VideoAnalyseCalibrateArea *area);


	/// 设置视频分析模块配置
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] count 模块数目，每个分析器可以设置多个模块
	/// \param [in] config 视频分析模块配置结构VideoAnalyseModuleConfig指针。
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*setModuleConfig)(struct VideoAnalyser *thiz, int count, VideoAnalyseModuleConfig *config);
	
	
	/// 开始分析。
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \retval 0  开始成功
	/// \retval <0	开始失败
	int (*start)(struct VideoAnalyser *thiz, int streamId);


	/// 停止分析。
	/// 
	/// \param [in]  thiz 视频分析接口指针
	/// \retval 0  停止成功
	/// \retval <0	停止失败
	int (*stop)(struct VideoAnalyser *thiz);
	
	
	/// 获取视频分析结果，只包含物体的基本信息
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] count 规则个数
	/// \param [in] param 视频分析结果videoAnalysePacket数组。
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*getPacket)(struct VideoAnalyser *thiz, VideoAnalysePacket *packet);


	/// 释放视频分析数据，需要和getPacket成对调用。
	///
	/// \param [in]  thiz 视频分析接口指针
	int (*releasePacket)(struct VideoAnalyser *thiz);


	/// 调用视频分析控制台，可以直接设置算法库参数。支持的命令行如下：
	/// "-set param value":将参数param的值设置为value	
	/// "-set param"	  :将参数param的值恢复为算法里的默认值
	/// "-print"		  :打印所有的参数
	/// "-recall"		  :将所有参数重置为算法的默认值
	/// 其他命令可自行定义。
	///
	/// \param [in]  thiz 视频分析接口指针
	/// \param [in]  argc 表示命令函数参数的个数，不包括命令本身的名称。
	/// \param [in]  argv 表示命令函数参数的列表，不包括命令本身的名称。
	/// \retval 0  调用成功
	/// \retval <0	调用失败
	int (*console)(struct VideoAnalyser *thiz, int argc, char **argv);


	/// 心跳命令.因为微码和上层是两个不同的程序,微码跑死后,该命令重启微码
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] format 视频输入格式结构指针。
	/// \retval 0  保活成功
	/// \retval <0	保活失败
	int (*heartbeat)(struct VideoAnalyser *thiz);		


	/// 设置待分析的视频的分辨率，帧率，旋转等格式。
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] format 视频分析格式结构指针。
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*setFormat)(struct VideoAnalyser *thiz, VideoAnalyseFormat *format);


	/// 设置DSP时间，和CPU同步
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] utc UTC(1970-1-1 00:00:00)时间
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*setTime)(struct VideoAnalyser *thiz, int utc);


	/// 设置视频分析模式，比如分析连续视频还是当作图片
	/// 
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] mode 视频分析模式
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*setMode)(struct VideoAnalyser *thiz, VideoAnalyseMode mode);


	/// 设置视频分析规则配置
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] count 规则数目，每个分析器可以设置多个规则
	/// \param [in] config 视频分析规则配置结构VideoAnalyseRuleConfig指针
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*setRuleConfig)(struct VideoAnalyser *thiz, int count, VideoAnalyseRuleConfig *config);


	/// 设置智能交通红绿灯状态
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] group 红绿灯组号
	/// \param [in] state 红绿灯状态,1:绿灯，2:红灯，3:黄灯
	int (*setTrafficLightState)(struct VideoAnalyser *thiz, int group, int state);

	
	/// 设置模块状态
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] index 模块编号
	/// \param [in] state 0-正常工作,1-暂停,再次切换到正常后画面可能已经发生变化,需要重建背景
	/// \note  重建背景,需要二次设置模块状态,状态从"暂停"切换到"正常工作";
	int (*setModuleState)(struct VideoAnalyser *thiz, int index, int state);

	
	/// 设置智能交通抓拍次数
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] count 违章类型个数，可以一次设置多个违章类型
	/// \param [in] snapTimes 违章类型抓拍次数结构VideoAnalyseTrafficSnapTimes指针
	/// \retval 0  设置成功
	/// \retval <0	设置失败
	int (*setTrafficSnapTimes)(struct VideoAnalyser *thiz, int count, VideoAnalyseTrafficSnapTimes* snapTimes);

	/// 设置跟踪轨迹
	/// 
	///	\param [in] thiz	视频分析接口指针
	/// \param [in] trackBytes 视频智能分析物体轨迹帧数据缓冲有效字节数
	/// \param [in] track 视频智能分析物体轨迹帧数据缓冲指针
	///	\retval 0 设置成功
	///	\retval <0 设置失败
	int (*setTrack)(struct VideoAnalyser *thiz, uint trackBytes, void* track);
	
	/// 取版本信息
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [out] version 存放版本信息的指针
	/// \retval 0  成功
	/// \retval <0	失败
	int (*getVersion)(struct VideoAnalyser *thiz, struct Version* version);

	/// 设置匹配模式
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] mode 匹配方式. 0表示非实时匹配，1表示实时匹配。
	/// \retval 0  成功
	/// \retval <0	失败
	int (*setMatchMode)(struct VideoAnalyser *thiz, int mode);

	/// 设置高级选项参数(注：高级复杂的字符命令)
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] 高级选项参数
	/// \param [in] 高级选项长度
	/// \retval 0 成功
	/// \retval <0 失败
	int (*setAdvancedOptions)(struct VideoAnalyser *thiz, char *options, int length);
	
	
	/// 设置视频分析事件通知回调函数
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] callback，	异常事件通知回调函数
	/// \retval 0 成功
	/// \retval <0 失败
	int (*setExceptionCallback)(struct VideoAnalyser *thiz, VideoAnalyseExceptionCallback callback);
	

	/// 根据屏幕坐标测试景深参数，得到的是两点之间的实际距离。在测试之前，需要先完成参数设置。
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] type	线段类型， 注 只能取值为 videoAnalyseHorizontal 水平线段  和videoAnalyseVertical 垂直线段
	/// \param [in] start 起始点坐标
	/// \param [in] end 终止点坐标
	/// \param [out] length	两点之间的实际长度	米为单位
	/// \retval 0 成功
	/// \retval <0 失败
	int (*testCalibrateWithScreenPoints)(struct VideoAnalyser *thiz, VideoAnalyseStaffType type, Point start, Point end, float * length);

		
	/// 根据实际长度、起始点及方向点坐标，测试景深参数，得到的是长度尺寸在目标位置的屏幕终点。在测试之前，需要先完成参数设置。
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] type	线段类型， 注 只能取值为 videoAnalyseHorizontal 水平线段  和videoAnalyseVertical 垂直线段，默认方向向上
	/// \param [in] length	两点之间的实际长度	米为单位
	/// \param [in] start 起始点坐标
	/// \param [in] direction 线段方向点坐标	只对水平线段有效;垂直线段，默认方向向上。
	/// \param [out] end 线段终点屏幕坐标	
	/// \retval 0 成功
	/// \retval <0 失败
	int (*testCalibrateWithMetricLength)(struct VideoAnalyser *thiz, VideoAnalyseStaffType type, float	length, Point start, Point direction, Point * end );


	/// 获取内部选项参数个数(注：数值型参数)
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [out] count 内部选项参数个数，
	/// \retval 0 成功
	/// \retval <0 失败
	int (*getInternalOptionCount)(struct VideoAnalyser *thiz,  int *count);


	/// 获取内部选项参数(注：数值型参数)
	///
	/// \param [in]		thiz 视频分析接口指针
	/// \param [in]		count 指定option内部选项参数缓冲区个数，如果选项参数超过count，只返回前count个参数
	/// \param [out]	retCount 返回的内部选项参数个数，<=count;	
	/// \param [out] option 内部选项参数，调用者分配和释放内存
	/// \retval 0 成功
	/// \retval <0 失败
	int (*getInternalOptions)(struct VideoAnalyser *thiz,  int count, VideoAnalyseInternalOption *option, int * retCount);

	/// 调整内部选项参数(注：数值型参数)
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] count 内部选项参数个数
	/// \param [in] option 内部选项参数
	/// \retval 0 成功
	/// \retval <0 失败
	int (*tuneInternalOptions)(struct VideoAnalyser *thiz, int count, VideoAnalyseInternalOption *option);

	/// 设置设备序列号
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] size 缓冲大小
	/// \param [in] serialNo 设备序列号指针
	/// \retval 0 成功
	/// \retval <0 失败
	int (*setSerialNo)(struct VideoAnalyser *thiz, int size, char *serialNo);
	
	/// 获取算法各个模块版本信息，getVersion失败时应调用此接口
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [out] version 存放版本信息的指针
	/// \param [in&out] count 输入最大的版本个数，返回实际的版本个数
	/// \retval 0  成功
	/// \retval <0	失败
	int (*getVersions)(struct VideoAnalyser *thiz, struct Version* version, int* count);
	
	/// 强制交通红灯
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] directionMask 交通灯指示的行驶方向. 从低位到高位分别表示:左转,直行,右转,掉头 ，1-强制红灯，0-取消强制
	/// \retval 0  成功
	/// \retval <0	失败
	int (*forceTrafficLightState)(struct VideoAnalyser *thiz, int directionMask);
	
	/// 设置算法鉴权值
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] key 算法鉴权信息
	/// \param [in] length 字符串长度
	/// \return 0 设置成功
	/// \return <0 失败
	int (*setAuthentication)(struct VideoAnalyser *thiz, char *key, int length);


	/// 取得算法处理器ID
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [out] info 算法处理器信息
	/// \return 0 获取成功
	/// \return <0 获取失败
	int (*getDSPInfo)(struct VideoAnalyser *thiz, VideoAnalyseDSPInfo *info);


	/// 人脸场景大小脸切换
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] facetype大小脸类型参数
	/// \retval 0 成功
	/// \retval <0 失败
	int (*setFaceType)(struct VideoAnalyser *thiz, VideoAnalyseFaceTypeDetection facetype);


	/// 发送YUV图像给DSP
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [int] videoyuv送到DSP的yuv数据
	/// \retval <0 发送失败
	/// \retval 0 发送成功
	int (*sendVideoYuv)(struct VideoAnalyser *thiz, VideoAnalyseVideoYuv *videoyuv);


	/// 设置覆盖区域（监视/录像覆盖，智能分析也要覆盖掉，不能在不可见区域进行智能分析）。
	/// 
	/// \param [in] index 区域覆盖的块数序号
	/// \param [in] pParam 指向视频覆盖结构VideoAnalyseCoverParam的指针。
	/// \retval 0  设置成功。
	/// \retval <0	设置失败。
	int (*setVideoCover)(struct VideoAnalyser *thiz, int index, VideoAnalyserVideoCover *videoCover);

	/// 强制抓拍产生违章
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] break 强制抓拍结构体指针
	/// \retval 0  成功
	/// \retval <0	失败
	int (*forceVideoBreaking)(struct VideoAnalyser *thiz, const VideoForceBreaking *breaking);

	/// 配置抓图属性
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] snapOption 强制抓图属性
	/// \retval 0  成功
	/// \retval <0	失败
	int (*setSnapOption)(struct VideoAnalyser *thiz, const VideoAnalyseSnapOption *snapOption);

	/// 设置智能交通车牌检测模式
	///
	/// \param [in]	thiz 视频分析接口指针
	/// \param [in]	车牌检测模式 静态、动态模式及混合模式
	/// \retval 0	设置成功
	/// \retval <0	设置失败
	int (*setTrafficWorkMode)(struct VideoAnalyser *thiz, VideoAnalysePlateRecognizeMode mode);

	/// 配置抓图OSD
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [in] snapOsdOption 抓图OSD属性
	/// \retval 0  成功
	/// \retval <0	失败
	int (*setSnapOSDOption)(struct VideoAnalyser *thiz, const VideoAnalyseSnapOSDInfo *snapOsdOption);

	/// 获取物体信息
	///
	/// \param [in] thiz 视频分析接口指针
	/// \param [out] packet 物体分析包
	/// \retval 0  成功
	/// \retval <0	失败
	int (*getVideoObjectData)(struct VideoAnalyser *thiz, VideoObjectPacket *packet);

	/// 算法结果返回数据帧跟视频帧延迟时间
	/// \param [out] time，单位ms
	/// \retval 0  成功
	/// \retval <0	失败
	int (*getDelayTime)(struct VideoAnalyser *thiz, uint *time);

    /// 选择当前预览画面的sensor
	/// \param [in] sensorId sensor的id号
	/// \retval 0  成功
	/// \retval <0	失败
	int (*selectSensor)(struct VideoAnalyser *thiz, int sensorId);

    /// 获取当前预览画面的sensor的id
	/// \param [out] sensorId sensor的id号
	/// \retval 0  成功
	/// \retval <0	失败
	int (*getSensorId)(struct VideoAnalyser *thiz, int* sensorId);

    /// 通知设备升级状态
    /// \param [in] flag 升级状态标记
	/// \retval 0  成功
	/// \retval <0	失败
    int (*notifyUpgradeStatus)(struct VideoAnalyser *thiz, int flag);
    
	///< 保留
	void* reserved[84];

} VideoAnalyser;


/// 得到视频分析最大通道的个数
int getVideoAnalyseChannels();


/// 内存信息结构体
typedef struct VideoAnalyseDataInfo
{
	void *buff;			///< 数据地址  
	uint len;			///< 数据长度
	int reserved[30];	///< 保留
}VideoAnalyseDataInfo;

/// 自定义的osd信息,128字节
typedef struct VideoAnalyseUserTitle
{
    int type;                           ///< 物体类型，详见VideoAnalyseObjectType
    int reserved[7];                    ///< 保留
    union
    {
        int unionReserved[24];
    };
}VideoAnalyseUserTitle;

/// 视频分析接口描述，132字节
typedef struct VideoAnalyseDesc
{
	VideoSurface *surface;			///< 待分析的视频输入表面
	int	channel;					///< 视频分析通道号
	unsigned int serviceTypeMask;	///< 智能算法服务类型掩码，由VideoAnalyseServiceType枚举掩码组成,支持多个算法同时开启
	int rebuidBgfrmCnt;				///< 重建背景所需图像帧数，如果为0，则表示默认值，否则指定大于0的值
	int card;						///< 子卡槽位号，0表示主板，>0表示子卡	
	VideoAnalyseVideoStandard videoStandard;	///< P制和N制 VideoStandard

    /// 底层调用该接口向应用层的内存写数据
    ///
    /// \param [in] memInfo 内存结构体数组的地址
    /// \param [in] size 内存结构体数组的大小
    /// \return 返回packet对象指针
    void* (*memoryWrite)(const VideoAnalyseDataInfo *dataInfo, uint size);

    /// 底层释放向应用申请的内存接口
    ///
    /// \param[in] packet 需要释放的packe对象的指针
    /// \retval 0 释放成功
    /// \retval <0 释放失败
    int (*memoryFree)(void *packet);

    /// 底层调用该接口获取智能抓图叠加的osd信息
    ///
    /// \param [in] userTitle 自定义osd信息
    /// \param [in] userTitleNum 自定义osd信息的个数
    /// \param [out] title，osd信息
    /// \param [in\out] titleNum，osd信息个数，输入最大个数，输出实际个数
    /// \retval 0  成功
	/// \retval <0	失败
    int (*getTitle)(VideoAnalyseUserTitle *userTitle, int userTitleNum, VideoTitle *title, int *titleNum);
	
    /// 底层调用该接口释放智能抓图叠加的osd信息
    ///
    /// \param [in] title，osd信息
    /// \param [in] titleNum，osd信息个数，输入最大个数，输出实际个数
    /// \retval 0  成功
	/// \retval <0	失败
    int (*putTitle)(VideoTitle *title, int titleNum);

	int reserved[23]; 				///< 保留
} VideoAnalyseDesc;


/// 创建视频分析接口
///
/// \param [in] dest 视频分析接口描述结构VideoAnalyseDesc指针
/// \param [out] VideoAnalyser 视频分析指针的指针
/// \retval <0 创建失败
/// \retval 0 创建成功
int PAL_API createVideoAnalyser(VideoAnalyseDesc *desc, VideoAnalyser **videoAnalyser);


/// 用于获取智能分析的消息，（注意：此函数会阻塞，直到获得消息或超时到才返回）
///
/// \param [in] timeout 超时返回时间，超时时间到，即使没有消息，函数将返回,单位：ms; -1 表示无限时长;
/// \param [out] message 视频分析消息结构体，指向内存由调用者管理；
/// \param [in&out] count 消息数量,既是输入参数，又是输出参数;				
/// \retval 0  成功
/// \retval <0	失败
/// \note count 作为输入参数时，表示的是，message结构体的内存大小个数；
		/// 作输出参数时，表示返回的消息数量。
		/// 注意：底层返回的消息个数，最大不能大于count作为输入时的数量。超过的，下次调用，再返回。
int PAL_API selectVideoAnalyserMessage(int timeout, VideoAnalyserMessage * message, int *count);

/// @} end of group

#ifdef __cplusplus
}
#endif

#endif //__VIDEO_ANALYSE_API_H__

